.TH std::experimental::function::function 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::experimental::function::function \- std::experimental::function::function

.SH Synopsis
                          (library
function() noexcept;  \fB(1)\fP fundamentals
                          TS)
function(                 (library
std::nullptr_t )      \fB(2)\fP fundamentals
noexcept;                 TS)
function( const           (library
function& other );    \fB(3)\fP fundamentals
                          TS)
function( function&&      (library
other );              \fB(4)\fP fundamentals
                          TS)
template< class F >       (library
function( F f );      \fB(5)\fP fundamentals
                          TS)
template< class Alloc
>                                      (library
function(                              fundamentals
std::allocator_arg_t,                  TS)
const Alloc& alloc )
noexcept;
function(
std::allocator_arg_t,                  (library
          const                        fundamentals
allocator_type& alloc                  TS v3)
) noexcept;
template< class Alloc
>

function(                                           (library
std::allocator_arg_t,                               fundamentals
const Alloc& alloc,                                 TS)


std::nullptr_t )
noexcept;
function(
std::allocator_arg_t,
const allocator_type&                               (library
alloc,                                              fundamentals
                                                    TS v3)
std::nullptr_t )
noexcept;
template< class Alloc
>

function(                                                        (library
std::allocator_arg_t,                                            fundamentals
const Alloc& alloc,   \fB(6)\fP                                        TS)

          const
function& other );
function(
std::allocator_arg_t,                                            (library
const allocator_type&     \fB(7)\fP                                    fundamentals
alloc,                                                           TS v3)
          const
function& other );
template< class Alloc
>

function(                                                                     (library
std::allocator_arg_t,                  \fB(8)\fP                                    fundamentals
const Alloc& alloc,                                                           TS)

          function&&
other );
function(
std::allocator_arg_t,                                                         (library
const allocator_type&                                                         fundamentals
alloc,                                              \fB(9)\fP                       TS v3)
          function&&
other );
template< class F,
class Alloc >                                                                              (library
function(                                                                                  fundamentals
std::allocator_arg_t,                                                                      TS)
const Alloc& alloc, F                                            \fB(10)\fP
f );
function(                                                                                  (library
std::allocator_arg_t,                                                                      fundamentals
const allocator_type&                                                                      TS v3)
alloc, F f );

   Constructs a std::experimental::function from a variety of sources.

   1,2) Creates an empty function.
   3) Copies the target of other to the target of *this. If other is empty, *this will
   be empty after the call too.
   4) Moves the target of other to the target of *this. If other is empty, *this will
   be empty after the call too.
   After construction, *this stores a copy of other.get_allocator().
   (library fundamentals TS v3)
   5) Initializes the target with a copy of f. If f is a null pointer to function or
   null pointer to member, *this will be empty after the call. This constructor does
   not participate in overload resolution unless f is Callable for argument types
   Args... and return type R.
   6-10) Same as (1-5) except that alloc is used to allocate memory for any internal
   data structures that the function might use.
   These constructors treat alloc as a type-erased allocator (see below).
   (until library fundamentals TS v3)

   After construction via (1-5), this->get_memory_resource()        (library
   returns the same value as                                        fundamentals TS)
   std::experimental::pmr::get_default_resource() during            (until library
   construction.                                                    fundamentals TS v3)
   After construction via (1-3) and \fB(5)\fP, *this stores a default     (library
   constructed std::pmr::polymorphic_allocator<>.                   fundamentals TS v3)

   When the target is a function pointer or a std::reference_wrapper, small object
   optimization is guaranteed, that is, these targets are always directly stored inside
   the std::experimental::function object, no dynamic allocation takes place. Other
   large objects may be constructed in dynamic allocated storage and accessed by the
   std::experimental::function object through a pointer.

   If a constructor moves or copies a function object, including an instance of
   std::experimental::function, then that move or copy is performed by using-allocator
   construction with allocator
   this->get_memory_resource()
   (until library fundamentals TS v3)
   this->get_allocator()
   (library fundamentals TS v3).

.SH Parameters

   other    -   the function object used to initialize *this
   f        -   a callable used to initialize *this
   alloc    -   an allocator used for internal memory allocation
.SH Type requirements
   -
   F must meet the requirements of Callable and CopyConstructible.

.SH Exceptions

   3,8) Does not throw if other's target is a function pointer or a
   std::reference_wrapper, otherwise may throw std::bad_alloc or any exception thrown
   by the copy constructor of the stored callable object.
   4) \fI(none)\fP
   5,10) Does not throw if f is a function pointer or a std::reference_wrapper,
   otherwise may throw std::bad_alloc or any exception thrown by the copy constructor
   of the stored callable object.
   9) \fI(none)\fP

.SH Example

    This section is incomplete
    Reason: no example

.SH Category:
     * Todo no example
